I see: RankOfFreeGroup belongs to GAP's FGA package, therefore the function FreeGroup cannot set this attribute. Thus the situation here is better.

Aye.

Regarding the definition of rank(::GrpAbFinGen) differing (it returns the Z-rank, or the "Hirsch length" to use polycyclic group terminology): ahh, that's a shame. Dang. Well, I could rename this function _rank for now, so that I can use it in the printing code (that was what motivated this PR), and then possibly again restrict it to support "free fp groups" only. And then worry about how to expose this to users later.

We should say what is meant with "is a free group".
GAP's IsFreeGroup means essentially a group created with free_group or a subgroup of such a group.
The GAP documentation is also vague about this, but it states that groups consisting of elements in the filter IsAssocWordWithInverse are regarded as free groups.

One could have the idea that "free group" means a group that is free on some set of elements, and then each trivial group is free on the empty set, and certain factors of free groups (for example where just some generators are mapped to the identity) are also free.

Thank you for this important observation.

Adding to it, also any infinite cyclic group (e.g. represented as a pcp group) would be "free". And yeah, in GAP we have this mathematically surprising situation then:

gap> G:=AbelianGroup([0]);
<fp group of size infinity on the generators [ f1 ]>
gap> IsFreeGroup(G);
false
gap> IsFreeGroup(FreeGroup(1));
true

So this is a case were one needs to distinguish between "mathematically free" (on some unknown set) and "technically free" (created as a free group), for lack of better terminology.

Both are of independent interest.... But I think a function is_free for groups should aim to check for the mathematical property, though of course it cannot in general (as long as we can't generally decide whether a fp group is trivial, we also can't decide freeness). But we can do it in many other cases, e.g. for finite groups (where is_free(G) = is_trivial(G)), pcp groups (either trivial or infinite cyclic, both can be tested for efficiently). For fp groups, we could make a best effort: compute abelian invariants; if any are non-zero, return false; otherwise we can read of the potential rank of the "free" group (if it is free); then use TzGoGo to try and simply (a copy of) the presentation to see if it is "obviously" free (= no relations left).

But of course what I really am using is the "technical interpretation". I actually thought already that perhaps we should split the FPGroup type not just into FPGroup and SubFPGroup (as we already discussed at PR #2672), but in fact also have FreeGroup (and perhaps also SubFreeGroup). In that case the "technical" check becomes a type check.

Yes, I think that the "technical interpretation" is used more frequently; also GAP's IsFreeGroup is just a filter, there was no aim to support a check for the mathematical property.

So do we need a better name for the "technical interpretation", in order to keep is_free for the mathematical one,
or do we decide that we introduce the type FreeGroup as mentioned above?

(I guess the name IsFreeGroup was chosen because people did not think that checking the mathematical property for arbitrary f. p. groups would be interesting. Moreover, as soon as such a function would be available, somebody would come and ask for a function that checks whether a group is free on a given set, and for a function that returns a set on which a given group is free ...)

GrpAbFinGen defines rank as the rank of the free part. Thus torsion groups created with abelian_group have always rank zero. If we really want to define rank for GAPGroup as the cardinality of a minimal generating set then perhaps we should mention this.